/**
 * 角色管理API客户端
 * 处理用户自定义角色的服务器端存储和加载
 */

import config from '../config/index.js';

const API_BASE_URL = config.API_BASE_URL;

/**
 * 获取授权头
 */
function getAuthHeaders() {
  const token = localStorage.getItem('authToken');
  return {
    'Content-Type': 'application/json',
    ...(token && { 'Authorization': `Bearer ${token}` })
  };
}

/**
 * 处理API响应
 */
async function handleResponse(response) {
  const data = await response.json();
  
  if (!response.ok) {
    config.logger.error('API请求失败:', data);
    throw new Error(data.error || '请求失败');
  }
  
  return data;
}

/**
 * 角色API类
 */
class RolesAPI {
  /**
   * 获取用户的自定义角色
   */
  static async getUserRoles() {
    try {
      config.logger.debug('🔄 从服务器获取用户角色数据...');
      
      const response = await fetch(`${API_BASE_URL}/roles/user-roles`, {
        method: 'GET',
        headers: getAuthHeaders()
      });
      
      const result = await handleResponse(response);
      
      config.logger.debug(`✅ 成功获取 ${result.data.count} 个用户角色`);
      config.logger.debug('角色数据最后更新时间:', result.data.lastUpdated);
      
      return result.data;
    } catch (error) {
      config.logger.error('❌ 获取用户角色失败:', error);
      
      // 如果是网络错误或服务器不可达，返回空数据
      if (error.message.includes('Failed to fetch') || error.name === 'TypeError') {
        config.logger.debug('🌐 服务器不可达或网络错误，返回空角色数据');
        return { roles: [], count: 0, lastUpdated: null };
      }
      
      // 如果是认证错误，返回空数据而不是抛出错误
      if (error.message.includes('Token') || error.message.includes('认证') || error.message.includes('401')) {
        config.logger.debug('🔓 用户未登录，返回空角色数据');
        return { roles: [], count: 0, lastUpdated: null };
      }
      
      // 其他错误也返回空数据，确保应用正常运行
      config.logger.debug('⚠️ 其他错误，返回空角色数据以确保应用正常运行');
      return { roles: [], count: 0, lastUpdated: null };
    }
  }

  /**
   * 保存用户的自定义角色
   */
  static async saveUserRoles(roles) {
    try {
      config.logger.debug(`💾 保存 ${roles.length} 个角色到服务器...`);
      
      const response = await fetch(`${API_BASE_URL}/roles/user-roles`, {
        method: 'POST',
        headers: getAuthHeaders(),
        body: JSON.stringify({ roles })
      });
      
      const result = await handleResponse(response);
      
      config.logger.debug(`✅ 成功保存 ${result.data.saved} 个角色到服务器`);
      if (result.data.filtered > 0) {
        config.logger.warn(`⚠️ 过滤掉 ${result.data.filtered} 个无效角色`);
      }
      
      return result.data;
    } catch (error) {
      config.logger.error('❌ 保存用户角色失败:', error);
      throw error;
    }
  }

  /**
   * 导入角色到用户收藏
   */
  static async importUserRoles(roles, operation = 'merge') {
    try {
      config.logger.debug(`📥 导入 ${roles.length} 个角色，操作类型: ${operation}`);
      
      const response = await fetch(`${API_BASE_URL}/roles/user-roles/import`, {
        method: 'POST',
        headers: getAuthHeaders(),
        body: JSON.stringify({ roles, operation })
      });
      
      const result = await handleResponse(response);
      
      config.logger.debug('✅ 角色导入完成:', result.data);
      
      return result.data;
    } catch (error) {
      config.logger.error('❌ 导入用户角色失败:', error);
      throw error;
    }
  }

  /**
   * 删除用户的特定角色
   */
  static async deleteUserRole(roleId) {
    try {
      config.logger.debug(`🗑️ 删除用户角色: ${roleId}`);
      
      const response = await fetch(`${API_BASE_URL}/roles/user-roles/${roleId}`, {
        method: 'DELETE',
        headers: getAuthHeaders()
      });
      
      const result = await handleResponse(response);
      
      config.logger.debug(`✅ 成功删除角色 ${roleId}`);
      
      return result.data;
    } catch (error) {
      config.logger.error('❌ 删除用户角色失败:', error);
      throw error;
    }
  }

  /**
   * 清空用户的所有自定义角色
   */
  static async clearUserRoles() {
    try {
      config.logger.debug('🧹 清空用户的所有自定义角色...');
      
      const response = await fetch(`${API_BASE_URL}/roles/user-roles`, {
        method: 'DELETE',
        headers: getAuthHeaders()
      });
      
      const result = await handleResponse(response);
      
      config.logger.debug('✅ 成功清空所有自定义角色');
      
      return result;
    } catch (error) {
      config.logger.error('❌ 清空用户角色失败:', error);
      throw error;
    }
  }

  /**
   * 同步本地角色数据到服务器
   */
  static async syncRolesToServer(localRoles) {
    try {
      if (!localRoles || localRoles.length === 0) {
        config.logger.debug('📝 本地无角色数据，跳过同步');
        return { synced: 0 };
      }

      config.logger.debug(`🔄 同步 ${localRoles.length} 个本地角色到服务器...`);
      
      // 获取服务器端角色数据
      const serverData = await this.getUserRoles();
      
      if (serverData.count === 0) {
        // 服务器端无数据，直接上传本地数据
        config.logger.debug('📤 服务器端无数据，上传本地角色');
        await this.saveUserRoles(localRoles);
        return { synced: localRoles.length, source: 'local-to-server' };
      } else {
        // 服务器端有数据，需要合并
        config.logger.debug('🔄 合并本地和服务器端角色数据');
        const result = await this.importUserRoles(localRoles, 'merge');
        return { synced: result.imported + result.updated, source: 'merged' };
      }
    } catch (error) {
      config.logger.error('❌ 同步角色数据失败:', error);
      // 同步失败不应该阻塞应用，返回失败信息
      return { synced: 0, error: error.message };
    }
  }

  /**
   * 从服务器加载角色数据到本地
   */
  static async loadRolesFromServer() {
    try {
      config.logger.debug('📥 从服务器加载角色数据...');
      
      const serverData = await this.getUserRoles();
      
      if (serverData.count > 0) {
        config.logger.debug(`✅ 从服务器加载了 ${serverData.count} 个角色`);
        
        // 验证加载的角色数据完整性
        const rolesWithAbility = serverData.roles.filter(r => r.ability);
        const rolesWithType = serverData.roles.filter(r => r.roleType);
        const officialRoles = serverData.roles.filter(r => r.roleType === 'official');
        const customRoles = serverData.roles.filter(r => r.roleType === 'custom');
        
        config.logger.debug(`📊 服务器数据验证:`);
        config.logger.debug(`   ├─ 包含能力描述: ${rolesWithAbility.length}/${serverData.count}`);
        config.logger.debug(`   ├─ 包含角色类型: ${rolesWithType.length}/${serverData.count}`);
        config.logger.debug(`   ├─ 官方角色: ${officialRoles.length} 个`);
        config.logger.debug(`   └─ 自定义角色: ${customRoles.length} 个`);
        
        // 显示前几个角色的详细信息
        serverData.roles.slice(0, Math.min(3, serverData.count)).forEach(role => {
          config.logger.debug(`🔍 角色验证 ${role.id}:`, {
            name: role.name,
            team: role.team,
            roleType: role.roleType || 'missing',
            hasAbility: !!role.ability,
            abilityPreview: role.ability?.substring(0, 40) + '...'
          });
        });
        
        return {
          roles: serverData.roles,
          count: serverData.count,
          lastUpdated: serverData.lastUpdated,
          source: 'server'
        };
      } else {
        config.logger.debug('📝 服务器端无角色数据');
        return {
          roles: [],
          count: 0,
          lastUpdated: null,
          source: 'server'
        };
      }
    } catch (error) {
      config.logger.error('❌ 从服务器加载角色失败:', error);
      
      // 提供更详细的错误信息
      let errorType = 'unknown';
      if (error.message.includes('Failed to fetch') || error.name === 'TypeError') {
        errorType = 'network';
        config.logger.debug('📡 网络连接问题，将使用本地缓存数据');
      } else if (error.message.includes('Token') || error.message.includes('401')) {
        errorType = 'auth';
        config.logger.debug('🔐 认证问题，将使用本地数据');
      } else {
        errorType = 'server';
        config.logger.debug('🔧 服务器问题，将使用本地数据');
      }
      
      // 加载失败时返回空数据，让应用继续运行
      return {
        roles: [],
        count: 0,
        lastUpdated: null,
        source: 'fallback',
        errorType,
        error: error.message
      };
    }
  }
}

export default RolesAPI;